/*
===========================================================================

Doom 3 GPL Source Code
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company. 

This file is part of the Doom 3 GPL Source Code (?Doom 3 Source Code?).  

Doom 3 Source Code is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

Doom 3 Source Code is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Doom 3 Source Code.  If not, see <http://www.gnu.org/licenses/>.

In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code.  If not, please request a copy in writing from id Software at the address below.

If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.

===========================================================================
*/

#include "../../../idlib/precompiled.h"
#pragma hdrstop

#include "Brush.h"
#include "BrushBSP.h"


#define BSP_GRID_SIZE					512.0f
#define SPLITTER_EPSILON				0.1f
#define VERTEX_MELT_EPSILON				0.1f
#define VERTEX_MELT_HASH_SIZE			32

#define PORTAL_PLANE_NORMAL_EPSILON		0.00001f
#define PORTAL_PLANE_DIST_EPSILON		0.01f

//#define OUPUT_BSP_STATS_PER_GRID_CELL


//===============================================================
//
//	idBrushBSPPortal
//
//===============================================================

/*
============
idBrushBSPPortal::idBrushBSPPortal
============
*/
idBrushBSPPortal::idBrushBSPPortal( void ) {
	planeNum = -1;
	winding = NULL;
	nodes[0] = nodes[1] = NULL;
	next[0] = next[1] = NULL;
	faceNum = 0;
	flags = 0;
}

/*
============
idBrushBSPPortal::~idBrushBSPPortal
============
*/
idBrushBSPPortal::~idBrushBSPPortal( void ) {
	if ( winding ) {
		delete winding;
	}
}

/*
============
idBrushBSPPortal::AddToNodes
============
*/
void idBrushBSPPortal::AddToNodes( idBrushBSPNode *front, idBrushBSPNode *back ) {
	if ( nodes[0] || nodes[1] ) {
		common->Error( "AddToNode: allready included" );
	}

	assert( front && back );

	nodes[0] = front;
	next[0] = front->portals;
	front->portals = this;
	
	nodes[1] = back;
	next[1] = back->portals;
	back->portals = this;
}

/*
============
idBrushBSPPortal::RemoveFromNode
============
*/
void idBrushBSPPortal::RemoveFromNode( idBrushBSPNode *l ) {
	idBrushBSPPortal **pp, *t;

	// remove reference to the current portal
	pp = &l->portals;
	while (1)
	{
		t = *pp;
		if ( !t ) {
			common->Error( "idBrushBSPPortal::RemoveFromNode: portal not in node" );
		}

		if ( t == this ) {
			break;
		}

		if ( t->nodes[0] == l ) {
			pp = &t->next[0];
		}
		else if ( t->nodes[1] == l ) {
			pp = &t->next[1];
		}
		else {
			common->Error( "idBrushBSPPortal::RemoveFromNode: portal not bounding node" );
		}
	}
	
	if ( nodes[0] == l ) {
		*pp = next[0];
		nodes[0] = NULL;
	}
	else if ( nodes[1] == l ) {
		*pp = next[1];	
		nodes[1] = NULL;
	}
	else {
		common->Error( "idBrushBSPPortal::RemoveFromNode: mislinked portal" );
	}
}

/*
============
idBrushBSPPortal::Flip
============
*/
void idBrushBSPPortal::Flip( void ) {
	idBrushBSPNode *frontNode, *backNode;

	frontNode = nodes[0];
	backNode = nodes[1];

	if ( frontNode ) {
		RemoveFromNode( frontNode );
	}
	if ( backNode ) {
		RemoveFromNode( backNode );
	}
	AddToNodes( frontNode, backNode );

	plane = -plane;
	planeNum ^= 1;
	winding->ReverseSelf();
}

/*
============
idBrushBSPPortal::Split
============
*/
int idBrushBSPPortal::Split( const idPlane &splitPlane, idBrushBSPPortal **front, idBrushBSPPortal **back ) {
	idWinding *frontWinding, *backWinding;

	(*front) = (*back) = NULL;
	winding->Split( splitPlane, 0.1f, &frontWinding, &backWinding );
	if ( frontWinding ) {
		(*front) = new idBrushBSPPortal();
		(*front)->plane = plane;
		(*front)->planeNum = planeNum;
		(*front)->flags = flags;
		(*front)->winding = frontWinding;
	}
	if ( backWinding ) {
		(*back) = new idBrushBSPPortal();
		(*back)->plane = plane;
		(*back)->planeNum = planeNum;
		(*back)->flags = flags;
		(*back)->winding = backWinding;
	}

	if ( frontWinding && backWinding ) {
		return PLANESIDE_CROSS;
	}
	else if ( frontWinding ) {
		return PLANESIDE_FRONT;
	}
	else {
		return PLANESIDE_BACK;
	}
}


//===============================================================
//
//	idBrushBSPNode
//
//===============================================================

/*
============
idBrushBSPNode::idBrushBSPNode
============
*/
idBrushBSPNode::idBrushBSPNode( void ) {
	brushList.Clear();
	contents = 0;
	flags = 0;
	volume = NULL;
	portals = NULL;
	children[0] = children[1] = NULL;
	areaNum = 0;
	occupied = 0;
}

/*
============
idBrushBSPNode::~idBrushBSPNode
============
*/
idBrushBSPNode::~idBrushBSPNode( void ) {
	idBrushBSPPortal *p;

	// delete brushes
	brushList.Free();

	// delete volume brush
	if ( volume ) {
		delete volume;
	}

	// delete portals
	for ( p = portals; p; p = portals ) {
		p->RemoveFromNode( this );
		if ( !p->nodes[0] && !p->nodes[1] ) {
			delete p;
		}
	}
}

/*
============
idBrushBSPNode::SetContentsFromBrushes
============
*/
void idBrushBSPNode::SetContentsFromBrushes( void ) {
	idBrush *brush;

	contents = 0;
	for ( brush = brushList.Head(); brush; brush = brush->Next() ) {
		contents |= brush->GetContents();
	}
}

/*
============
idBrushBSPNode::GetPortalBounds
============
*/
idBounds idBrushBSPNode::GetPortalBounds( void ) {
	int s, i;
	idBrushBSPPortal *p;
	idBounds bounds;

	bounds.Clear();
	for ( p = portals; p; p = p->next[s] ) {
		s = (p->nodes[1] == this);

		for ( i = 0; i < p->winding->GetNumPoints(); i++ ) {
			bounds.AddPoint( (*p->winding)[i].ToVec3() );
		}
	}
	return bounds;
}

/*
============
idBrushBSPNode::TestLeafNode
============
*/
bool idBrushBSPNode::TestLeafNode( void ) {
	int s, n;
	float d;
	idBrushBSPPortal *p;
	idVec3 center;
	idPlane plane;

	n = 0;
	center = vec3_origin;
	for ( p = portals; p; p = p->next[s] ) {
		s = (p->nodes[1] == this);
		center += p->winding->GetCenter();
		n++;
	}

	center /= n;

	for ( p = portals; p; p = p->next[s] ) {
		s = (p->nodes[1] == this);
		if ( s ) {
			plane = -p->GetPlane();
		}
		else {
			plane = p->GetPlane();
		}
		d = plane.Distance( center );
		if ( d < 0.0f ) {
			return false;
		}
	}
	return true;
}

/*
============
idBrushBSPNode::Split
============
*/
bool idBrushBSPNode::Split( const idPlane &splitPlane, int splitPlaneNum ) {
	int s, i;
	idWinding *mid;
	idBrushBSPPortal *p, *midPortal, *newPortals[2];
	idBrushBSPNode *newNodes[2];

	mid = new idWinding( splitPlane.Normal(), splitPlane.Dist() );

	for ( p = portals; p && mid; p = p->next[s] ) {
		s = (p->nodes[1] == this);
		if ( s ) {
			mid = mid->Clip( -p->plane, 0.1f, false );
		}
		else {
			mid = mid->Clip( p->plane, 0.1f, false );
		}
	}

	if ( !mid ) {
		return false;
	}

	// allocate two new nodes
	for ( i = 0; i < 2; i++ ) {
		newNodes[i] = new idBrushBSPNode();
		newNodes[i]->flags = flags;
		newNodes[i]->contents = contents;
		newNodes[i]->parent = this;
	}

	// split all portals of the node
	for ( p = portals; p; p = portals ) {
		s = (p->nodes[1] == this);
		p->Split( splitPlane, &newPortals[0], &newPortals[1] );
		for ( i = 0; i < 2; i++ ) {
			if ( newPortals[i] ) {
				if ( s ) {
					newPortals[i]->AddToNodes( p->nodes[0], newNodes[i] );
				}
				else {
					newPortals[i]->AddToNodes( newNodes[i], p->nodes[1] );
				}
			}
		}
		p->RemoveFromNode( p->nodes[0] );
		p->RemoveFromNode( p->nodes[1] );
		delete p;
	}

	// add seperating portal
	midPortal = new idBrushBSPPortal();
	midPortal->plane = splitPlane;
	midPortal->planeNum = splitPlaneNum;
	midPortal->winding = mid;
	midPortal->AddToNodes( newNodes[0], newNodes[1] );

	// set new child nodes
	children[0] = newNodes[0];
	children[1] = newNodes[1];
	plane = splitPlane;

	return true;
}

/*
============
idBrushBSPNode::PlaneSide
============
*/
int idBrushBSPNode::PlaneSide( const idPlane &plane, float epsilon ) const {
	int s, side;
	idBrushBSPPortal *p;
	bool front, back;

	front = back = false;
	for ( p = portals; p; p = p->next[s] ) {
		s = (p->nodes[1] == this);

		side = p->winding->PlaneSide( plane, epsilon );
		if ( side == SIDE_CROSS || side == SIDE_ON) {
			return side;
		}
		if ( side == SIDE_FRONT ) {
			if ( back ) {
				return SIDE_CROSS;
			}
			front = true;
		}
		if ( side == SIDE_BACK ) {
			if ( front ) {
				return SIDE_CROSS;
			}
			back = true;
		}
	}

	if ( front ) {
		return SIDE_FRONT;
	}
	return SIDE_BACK;
}

/*
============
idBrushBSPNode::RemoveFlagFlood
============
*/
void idBrushBSPNode::RemoveFlagFlood( int flag ) {
	int s;
	idBrushBSPPortal *p;

	RemoveFlag( flag );

	for ( p = GetPortals(); p; p = p->Next(s) ) {
		s = (p->GetNode(1) == this);

		if ( !(p->GetNode( !s )->GetFlags() & flag ) ) {
			continue;
		}

		p->GetNode( !s )->RemoveFlagFlood( flag );
	}
}

/*
============
idBrushBSPNode::RemoveFlagRecurse
============
*/
void idBrushBSPNode::RemoveFlagRecurse( int flag ) {
	RemoveFlag( flag );
	if ( children[0] ) {
		children[0]->RemoveFlagRecurse( flag );
	}
	if ( children[1] ) {
		children[1]->RemoveFlagRecurse( flag );
	}
}

/*
============
idBrushBSPNode::RemoveFlagRecurseFlood
============
*/
void idBrushBSPNode::RemoveFlagRecurseFlood( int flag ) {
	RemoveFlag( flag );
	if ( !children[0] && !children[1] ) {
		RemoveFlagFlood( flag );
	}
	else {
		if ( children[0] ) {
			children[0]->RemoveFlagRecurseFlood( flag );
		}
		if ( children[1] ) {
			children[1]->RemoveFlagRecurseFlood( flag );
		}
	}
}


//===============================================================
//
//	idBrushBSP
//
//===============================================================

/*
============
idBrushBSP::idBrushBSP
============
*/
idBrushBSP::idBrushBSP( void ) {
	root = outside = NULL;
	numSplits = numPrunedSplits = 0;
	brushMapContents = 0;
	brushMap = NULL;
}

/*
============
idBrushBSP::~idBrushBSP
============
*/
idBrushBSP::~idBrushBSP( void ) {

	RemoveMultipleLeafNodeReferences_r( root );
	Free_r( root );

	if ( outside ) {
		delete outside;
	}
}

/*
============
idBrushBSP::RemoveMultipleLeafNodeReferences_r
============
*/
void idBrushBSP::RemoveMultipleLeafNodeReferences_r( idBrushBSPNode *node ) {
	if ( !node ) {
		return;
	}

	if ( node->children[0] ) {
		if ( node->children[0]->parent != node ) {
			node->children[0] = NULL;
		}
		else {
			RemoveMultipleLeafNodeReferences_r( node->children[0] );
		}
	}
	if ( node->children[1] ) {
		if ( node->children[1]->parent != node ) {
			node->children[1] = NULL;
		}
		else {
			RemoveMultipleLeafNodeReferences_r( node->children[1] );
		}
	}
}

/*
============
idBrushBSP::Free_r
============
*/
void idBrushBSP::Free_r( idBrushBSPNode *node ) {
	if ( !node ) {
		return;
	}

	Free_r( node->children[0] );
	Free_r( node->children[1] );

	delete node;
}

/*
============
idBrushBSP::IsValidSplitter
============
*/
ID_INLINE bool idBrushBSP::IsValidSplitter( const idBrushSide *side ) {
	return !( side->GetFlags() & ( SFL_SPLIT | SFL_USED_SPLITTER ) );
}

/*
============
idBrushBSP::BrushSplitterStats
============
*/
typedef struct splitterStats_s {
	int numFront;			// number of brushes at the front of the splitter
	int numBack;			// number of brushes at the back of the splitter
	int numSplits;			// number of brush sides split by the splitter
	int numFacing;			// number of brushes facing this splitter
	int epsilonBrushes;		// number of tiny brushes this splitter would create
} splitterStats_t;

int idBrushBSP::BrushSplitterStats( const idBrush *brush, int planeNum, const idPlaneSet &planeList, bool *testedPlanes, struct splitterStats_s &stats ) {
	int i, j, num, s, lastNumSplits;
	const idPlane *plane;
	const idWinding *w;
	float d, d_front, d_back, brush_front, brush_back;

	plane = &planeList[planeNum];

	// get the plane side for the brush bounds
	s = brush->GetBounds().PlaneSide( *plane, SPLITTER_EPSILON );
	if ( s == PLANESIDE_FRONT ) {
		stats.numFront++;
		return BRUSH_PLANESIDE_FRONT;
	}
	if ( s == PLANESIDE_BACK ) {
		stats.numBack++;
		return BRUSH_PLANESIDE_BACK;
	}

	// if the brush actually uses the planenum, we can tell the side for sure
	for ( i = 0; i < brush->GetNumSides(); i++ ) {
		num = brush->GetSide( i )->GetPlaneNum();

		if ( !(( num ^ planeNum ) >> 1) ) {
			if ( num == planeNum ) {
				stats.numBack++;
				stats.numFacing++;
				return ( BRUSH_PLANESIDE_BACK | BRUSH_PLANESIDE_FACING );
			}
			if ( num == ( planeNum ^ 1 ) ) {
				stats.numFront++;
				stats.numFacing++;
				return ( BRUSH_PLANESIDE_FRONT | BRUSH_PLANESIDE_FACING );
			}
		}
	}

	lastNumSplits = stats.numSplits;
	brush_front = brush_back = 0.0f;
	for ( i = 0; i < brush->GetNumSides(); i++ ) {

		if ( !IsValidSplitter( brush->GetSide( i ) ) ) {
			continue;
		}

		j = brush->GetSide( i )->GetPlaneNum();
		if ( testedPlanes[j] || testedPlanes[j^1] ) {
			continue;
		}

		w = brush->GetSide(i)->GetWinding();
		if ( !w ) {
			continue;
		}
		d_front = d_back = 0.0f;
		for ( j = 0; j < w->GetNumPoints(); j++ ) {
			d = plane->Distance( (*w)[j].ToVec3() );
			if ( d > d_front ) {
				d_front = d;
			}
			else if ( d < d_back ) {
				d_back = d;
			}
		}
		if ( d_front > SPLITTER_EPSILON && d_back < -SPLITTER_EPSILON ) {
			stats.numSplits++;
		}
		if ( d_front > brush_front ) {
			brush_front = d_front;
		}
		else if ( d_back < brush_back ) {
			brush_back = d_back;
		}
	}

	// if brush sides are split and the brush only pokes one unit through the plane
	if ( stats.numSplits > lastNumSplits && (brush_front < 1.0f || brush_back > -1.0f) ) {
		stats.epsilonBrushes++;
	}

	return BRUSH_PLANESIDE_BOTH;
}

/*
============
idBrushBSP::FindSplitter
============
*/
int idBrushBSP::FindSplitter( idBrushBSPNode *node, const idPlaneSet &planeList, bool *testedPlanes, struct splitterStats_s &bestStats ) {
	int i, planeNum, bestSplitter, value, bestValue, f, numBrushSides;
	idBrush *brush, *b;
	splitterStats_t stats;

	memset( testedPlanes, 0, planeList.Num() * sizeof( bool ) );

	bestSplitter = -1;
	bestValue = -99999999;
	for ( brush = node->brushList.Head(); brush; brush = brush->Next() ) {

		if ( brush->GetFlags() & BFL_NO_VALID_SPLITTERS ) {
			continue;
		}

		for ( i = 0; i < brush->GetNumSides(); i++ ) {

			if ( !IsValidSplitter( brush->GetSide(i) ) ) {
				continue;
			}

			planeNum = brush->GetSide(i)->GetPlaneNum();

			if ( testedPlanes[planeNum] || testedPlanes[planeNum^1] ) {
				continue;
			}

			testedPlanes[planeNum] = testedPlanes[planeNum^1] = true;

			if ( node->volume->Split( planeList[planeNum], planeNum, NULL, NULL ) != PLANESIDE_CROSS ) {
				continue;
			}

			memset( &stats, 0, sizeof( stats ) );

			f = 15 + 5 * (brush->GetSide(i)->GetPlane().Type() < PLANETYPE_TRUEAXIAL);
			numBrushSides = node->brushList.NumSides();

			for ( b = node->brushList.Head(); b; b = b->Next() ) {

				// if the brush has no valid splitters left
				if ( b->GetFlags() & BFL_NO_VALID_SPLITTERS ) {
					b->SetPlaneSide( BRUSH_PLANESIDE_BOTH );
				}
				else {
					b->SetPlaneSide( BrushSplitterStats( b, planeNum, planeList, testedPlanes, stats ) );
				}

				numBrushSides -= b->GetNumSides();
				// best value we can get using this plane as a splitter
				value = f * (stats.numFacing + numBrushSides) - 10 * stats.numSplits - stats.epsilonBrushes * 1000;
				// if the best value for this plane can't get any better than the best value we have
				if ( value < bestValue ) {
					break;
				}
			}

			if ( b ) {
				continue;
			}

			value = f * stats.numFacing - 10 * stats.numSplits - abs(stats.numFront - stats.numBack) - stats.epsilonBrushes * 1000;

			if ( value > bestValue ) {
				bestValue = value;
				bestSplitter = planeNum;
				bestStats = stats;

				for ( b = node->brushList.Head(); b; b = b->Next() ) {
					b->SavePlaneSide();
				}
			}
		}
	}

	return bestSplitter;
}

/*
============
idBrushBSP::SetSplitterUsed
============
*/
void idBrushBSP::SetSplitterUsed( idBrushBSPNode *node, int planeNum ) {
	int i, numValidBrushSplitters;
	idBrush *brush;

	for ( brush = node->brushList.Head(); brush; brush = brush->Next() ) {
		if ( !( brush->GetSavedPlaneSide() & BRUSH_PLANESIDE_FACING ) ) {
			continue;
		}
		numValidBrushSplitters = 0;
		for ( i = 0; i < brush->GetNumSides(); i++ ) {

			if ( !(( brush->GetSide(i)->GetPlaneNum() ^ planeNum ) >> 1) ) {
				brush->GetSide(i)->SetFlag( SFL_USED_SPLITTER );
			}
			else if ( IsValidSplitter( brush->GetSide(i) ) ) {
				numValidBrushSplitters++;
			}
		}
		if ( numValidBrushSplitters == 0 ) {
			brush->SetFlag( BFL_NO_VALID_SPLITTERS );
		}
	}
}

/*
============
idBrushBSP::BuildBrushBSP_r
============
*/
idBrushBSPNode *idBrushBSP::BuildBrushBSP_r( idBrushBSPNode *node, const idPlaneSet &planeList, bool *testedPlanes, int skipContents ) {
	int planeNum;
	splitterStats_t bestStats;

	planeNum = FindSplitter( node, planeList, testedPlanes, bestStats );

	// if no split plane found this is a leaf node
	if ( planeNum == -1 ) {

		node->SetContentsFromBrushes();

		if ( brushMap && ( node->contents & brushMapContents ) ) {
			brushMap->WriteBrush( node->volume );
		}

		// free node memory
		node->brushList.Free();
		delete node->volume;
		node->volume = NULL;

		node->children[0] = node->children[1] = NULL;
		return node;
	}

	numSplits++;
	numGridCellSplits++;

	// mark all brush sides on the split plane as used
	SetSplitterUsed( node, planeNum );

	// set node split plane
	node->plane = planeList[planeNum];

	// allocate children
	node->children[0] = new idBrushBSPNode();
	node->children[1] = new idBrushBSPNode();

	// split node volume and brush list for children
	node->volume->Split( node->plane, -1, &node->children[0]->volume, &node->children[1]->volume );
	node->brushList.Split( node->plane, -1, node->children[0]->brushList, node->children[1]->brushList, true );
	node->children[0]->parent = node->children[1]->parent = node;

	// free node memory
	node->brushList.Free();
	delete node->volume;
	node->volume = NULL;

	// process children
	node->children[0] = BuildBrushBSP_r( node->children[0], planeList, testedPlanes, skipContents );
	node->children[1] = BuildBrushBSP_r( node->children[1], planeList, testedPlanes, skipContents );

	// if both children contain the skip contents
	if ( node->children[0]->contents & node->children[1]->contents & skipContents ) {
		node->contents = node->children[0]->contents | node->children[1]->contents;
		delete node->children[0];
		delete node->children[1];
		node->children[0] = node->children[1] = NULL;
		numSplits--;
		numGridCellSplits--;
	}

	return node;
}

/*
============
idBrushBSP::ProcessGridCell
============
*/
idBrushBSPNode *idBrushBSP::ProcessGridCell( idBrushBSPNode *node, int skipContents ) {
	idPlaneSet planeList;
	bool *testedPlanes;

#ifdef OUPUT_BSP_STATS_PER_GRID_CELL
	common->Printf( "[Grid Cell %d]\n", ++numGridCells );
	common->Printf( "%6d brushes\n", node->brushList.Num() );
#endif

	numGridCellSplits = 0;

	// chop away all brush overlap
	node->brushList.Chop( BrushChopAllowed );

	// merge brushes if possible
	//node->brushList.Merge( BrushMergeAllowed );

	// create a list with planes for this grid cell
	node->brushList.CreatePlaneList( planeList );

#ifdef OUPUT_BSP_STATS_PER_GRID_CELL
	common->Printf( "[Grid Cell BSP]\n" );
#endif

	testedPlanes = new bool[planeList.Num()];

	BuildBrushBSP_r( node, planeList, testedPlanes, skipContents );

	delete testedPlanes;

#ifdef OUPUT_BSP_STATS_PER_GRID_CELL
	common->Printf( "\r%6d splits\n", numGridCellSplits );
#endif

	return node;
}

/*
============
idBrushBSP::BuildGrid_r
============
*/
void idBrushBSP::BuildGrid_r( idList<idBrushBSPNode *> &gridCells, idBrushBSPNode *node ) {
	int axis;
	float dist;
	idBounds bounds;
	idVec3 normal, halfSize;

	if ( !node->brushList.Num() ) {
		delete node->volume;
		node->volume = NULL;
		node->children[0] = node->children[1] = NULL;
		return;
	}

	bounds = node->volume->GetBounds();
	halfSize = (bounds[1] - bounds[0]) * 0.5f;
	for ( axis = 0; axis < 3; axis++ ) {
		if ( halfSize[axis] > BSP_GRID_SIZE ) {
			dist = BSP_GRID_SIZE * ( floor( (bounds[0][axis] + halfSize[axis]) / BSP_GRID_SIZE ) + 1 );
		}
		else {
			dist = BSP_GRID_SIZE * ( floor( bounds[0][axis] / BSP_GRID_SIZE ) + 1 );
		}
		if ( dist > bounds[0][axis] + 1.0f && dist < bounds[1][axis] - 1.0f ) {
			break;
		}
	}
	if ( axis >= 3 ) {
		gridCells.Append( node );
		return;
	}

	numSplits++;

	normal = vec3_origin;
	normal[axis] = 1.0f;
	node->plane.SetNormal( normal );
	node->plane.SetDist( (int) dist );

	// allocate children
	node->children[0] = new idBrushBSPNode();
	node->children[1] = new idBrushBSPNode();

	// split volume and brush list for children
	node->volume->Split( node->plane, -1, &node->children[0]->volume, &node->children[1]->volume );
	node->brushList.Split( node->plane, -1, node->children[0]->brushList, node->children[1]->brushList );
	node->children[0]->brushList.SetFlagOnFacingBrushSides( node->plane, SFL_USED_SPLITTER );
	node->children[1]->brushList.SetFlagOnFacingBrushSides( node->plane, SFL_USED_SPLITTER );
	node->children[0]->parent = node->children[1]->parent = node;

	// free node memory
	node->brushList.Free();
	delete node->volume;
	node->volume = NULL;

	// process children
	BuildGrid_r( gridCells, node->children[0] );
	BuildGrid_r( gridCells, node->children[1] );
}

/*
============
idBrushBSP::Build
============
*/
void idBrushBSP::Build( idBrushList brushList, int skipContents,
								bool (*ChopAllowed)( idBrush *b1, idBrush *b2 ),
								bool (*MergeAllowed)( idBrush *b1, idBrush *b2 ) ) {

	int i;
	idList<idBrushBSPNode *> gridCells;

	common->Printf( "[Brush BSP]\n" );
	common->Printf( "%6d brushes\n", brushList.Num() );

	BrushChopAllowed = ChopAllowed;
	BrushMergeAllowed = MergeAllowed;

	numGridCells = 0;
	treeBounds = brushList.GetBounds();
	root = new idBrushBSPNode();
	root->brushList = brushList;
	root->volume = new idBrush();
	root->volume->FromBounds( treeBounds );
	root->parent = NULL;

	BuildGrid_r( gridCells, root );

	common->Printf( "\r%6d grid cells\n", gridCells.Num() );

#ifdef OUPUT_BSP_STATS_PER_GRID_CELL
	for ( i = 0; i < gridCells.Num(); i++ ) {
		ProcessGridCell( gridCells[i], skipContents );
	}
#else
	common->Printf( "\r%6d %%", 0 );
	for ( i = 0; i < gridCells.Num(); i++ ) {
		DisplayRealTimeString( "\r%6d", i * 100 / gridCells.Num() );
		ProcessGridCell( gridCells[i], skipContents );
	}
	common->Printf( "\r%6d %%\n", 100 );
#endif

	common->Printf( "\r%6d splits\n", numSplits );

	if ( brushMap ) {
		delete brushMap;
	}
}

/*
============
idBrushBSP::WriteBrushMap
============
*/
void idBrushBSP::WriteBrushMap( const idStr &fileName, const idStr &ext, int contents ) {
	brushMap = new idBrushMap( fileName, ext );
	brushMapContents = contents;
}

/*
============
idBrushBSP::PruneTree_r
============
*/
void idBrushBSP::PruneTree_r( idBrushBSPNode *node, int contents ) {
	int i, s;
	idBrushBSPNode *nodes[2];
	idBrushBSPPortal *p, *nextp;

	if ( !node->children[0] || !node->children[1] ) {
		return;
	}

	PruneTree_r( node->children[0], contents );
	PruneTree_r( node->children[1], contents );

	if ( ( node->children[0]->contents & node->children[1]->contents & contents ) ) {

		node->contents = node->children[0]->contents | node->children[1]->contents;
		// move all child portals to parent
		for ( i = 0; i < 2; i++ ) {
			for ( p = node->children[i]->portals; p; p = nextp ) {
				s = ( p->nodes[1] == node->children[i] );
				nextp = p->next[s];
				nodes[s] = node;
				nodes[!s] = p->nodes[!s];
				p->RemoveFromNode( p->nodes[0] );
				p->RemoveFromNode( p->nodes[1] );
				if ( nodes[!s] == node->children[!i] ) {
					delete p;	// portal seperates both children
				}
				else {
					p->AddToNodes( nodes[0], nodes[1] );
				}
			}
		}

		delete node->children[0];
		delete node->children[1];
		node->children[0] = NULL;
		node->children[1] = NULL;

		numPrunedSplits++;
	}
}

/*
============
idBrushBSP::PruneTree
============
*/
void idBrushBSP::PruneTree( int contents ) {
	numPrunedSplits = 0;
	common->Printf( "[Prune BSP]\n" );
	PruneTree_r( root, contents );
	common->Printf( "%6d splits pruned\n", numPrunedSplits );
}

/*
============
idBrushBSP::BaseWindingForNode
============
*/
#define	BASE_WINDING_EPSILON		0.001f

idWinding *idBrushBSP::BaseWindingForNode( idBrushBSPNode *node ) {
	idWinding *w;
	idBrushBSPNode *n;

	w = new idWinding( node->plane.Normal(), node->plane.Dist() );

	// clip by all the parents
	for ( n = node->parent; n && w; n = n->parent ) {

		if ( n->children[0] == node ) {
			// take front
			w = w->Clip( n->plane, BASE_WINDING_EPSILON );
		}
		else {
			// take back
			w = w->Clip( -n->plane, BASE_WINDING_EPSILON );
		}
		node = n;
	}

	return w;
}

/*
============
idBrushBSP::MakeNodePortal

  create the new portal by taking the full plane winding for the cutting
  plane and clipping it by all of parents of this node
============
*/
void idBrushBSP::MakeNodePortal( idBrushBSPNode *node ) {
	idBrushBSPPortal *newPortal, *p;
	idWinding *w;
	int side;

	w = BaseWindingForNode( node );

	// clip the portal by all the other portals in the node
	for ( p = node->portals; p && w; p = p->next[side] ) {
		if ( p->nodes[0] == node ) {
			side = 0;
			w = w->Clip( p->plane, 0.1f );
		}
		else if ( p->nodes[1] == node ) {
			side = 1;
			w = w->Clip( -p->plane, 0.1f );
		}
		else {
			common->Error( "MakeNodePortal: mislinked portal" );
		}
	}

	if ( !w ) {
		return;
	}

	if ( w->IsTiny() ) {
		delete w;
		return;
	}

	newPortal = new idBrushBSPPortal();
	newPortal->plane = node->plane;
	newPortal->winding = w;
	newPortal->AddToNodes( node->children[0], node->children[1] );
}

/*
============
idBrushBSP::SplitNodePortals

  Move or split the portals that bound the node so that the node's children have portals instead of node.
============
*/
#define	SPLIT_WINDING_EPSILON		0.001f

void idBrushBSP::SplitNodePortals( idBrushBSPNode *node ) {
	int side;
	idBrushBSPPortal *p, *nextPortal, *newPortal;
	idBrushBSPNode *f, *b, *otherNode;
	idPlane *plane;
	idWinding *frontWinding, *backWinding;

	plane = &node->plane;
	f = node->children[0];
	b = node->children[1];

	for ( p = node->portals; p; p = nextPortal ) {
		if (p->nodes[0] == node) {
			side = 0;
		}
		else if (p->nodes[1] == node) {
			side = 1;
		}
		else {
			common->Error( "idBrushBSP::SplitNodePortals: mislinked portal" );
		}
		nextPortal = p->next[side];

		otherNode = p->nodes[!side];
		p->RemoveFromNode( p->nodes[0] );
		p->RemoveFromNode( p->nodes[1] );

		// cut the portal into two portals, one on each side of the cut plane
		p->winding->Split( *plane, SPLIT_WINDING_EPSILON, &frontWinding, &backWinding );

		if ( frontWinding && frontWinding->IsTiny() ) {
			delete frontWinding;
			frontWinding = NULL;
			//tinyportals++;
		}

		if ( backWinding && backWinding->IsTiny() ) {
			delete backWinding;
			backWinding = NULL;
			//tinyportals++;
		}

		if ( !frontWinding && !backWinding ) {
			// tiny windings on both sides
			continue;
		}

		if ( !frontWinding ) {
			delete backWinding;
			if ( side == 0 ) {
				p->AddToNodes( b, otherNode );
			}
			else {
				p->AddToNodes( otherNode, b );
			}
			continue;
		}
		if ( !backWinding ) {
			delete frontWinding;
			if ( side == 0 ) {
				p->AddToNodes( f, otherNode );
			}
			else {
				p->AddToNodes( otherNode, f );
			}
			continue;
		}
		
		// the winding is split
		newPortal = new idBrushBSPPortal();
		*newPortal = *p;
		newPortal->winding = backWinding;
		delete p->winding;
		p->winding = frontWinding;

		if ( side == 0 ) {
			p->AddToNodes( f, otherNode );
			newPortal->AddToNodes( b, otherNode );
		}
		else {
			p->AddToNodes( otherNode, f );
			newPortal->AddToNodes( otherNode, b );
		}
	}

	node->portals = NULL;
}

/*
============
idBrushBSP::MakeTreePortals_r
============
*/
void idBrushBSP::MakeTreePortals_r( idBrushBSPNode *node ) {
	int i;
	idBounds bounds;

	numPortals++;
	DisplayRealTimeString( "\r%6d", numPortals );

	bounds = node->GetPortalBounds();

	if ( bounds[0][0] >= bounds[1][0] ) {
		//common->Warning( "node without volume" );
	}

	for ( i = 0; i < 3; i++ ) {
		if ( bounds[0][i] < MIN_WORLD_COORD || bounds[1][i] > MAX_WORLD_COORD ) {
			common->Warning( "node with unbounded volume" );
			break;
		}
	}

	if ( !node->children[0] || !node->children[1] ) {
		return;
	}

	MakeNodePortal( node );
	SplitNodePortals( node );

	MakeTreePortals_r( node->children[0] );
	MakeTreePortals_r( node->children[1] );
}

/*
============
idBrushBSP::MakeOutsidePortals
============
*/
void idBrushBSP::MakeOutsidePortals( void ) {
	int i, j, n;
	idBounds bounds;
	idBrushBSPPortal *p, *portals[6];
	idVec3 normal;
	idPlane planes[6];

	// pad with some space so there will never be null volume leaves
	bounds = treeBounds.Expand( 32 );

	for ( i = 0; i < 3; i++ ) {
		if ( bounds[0][i] > bounds[1][i] ) {
			common->Error( "empty BSP tree" );
		}
	}

	outside = new idBrushBSPNode();
	outside->parent = NULL;
	outside->children[0] = outside->children[1] = NULL;
	outside->brushList.Clear();
	outside->portals = NULL;
	outside->contents = 0;

	for ( i = 0; i < 3; i++ ) {
		for ( j = 0; j < 2; j++ ) {

			p = new idBrushBSPPortal();
			normal = vec3_origin;
			normal[i] = j ? -1 : 1;
			p->plane.SetNormal( normal );
			p->plane.SetDist( j ? -bounds[j][i] : bounds[j][i] );
			p->winding = new idWinding( p->plane.Normal(), p->plane.Dist() );
			p->AddToNodes( root, outside );

			n = j * 3 + i;
			portals[n] = p;
		}
	}
		
	// clip the base windings with all the other planes
	for ( i = 0; i < 6; i++ ) {
		for ( j = 0; j < 6; j++ ) {
			if (j == i) {
				continue;
			}
			portals[i]->winding = portals[i]->winding->Clip( portals[j]->plane, ON_EPSILON );
		}
	}
    
    UNUSED_VAR(planes);
}

/*
============
idBrushBSP::Portalize
============
*/
void idBrushBSP::Portalize( void ) {
	common->Printf( "[Portalize BSP]\n" );
	common->Printf( "%6d nodes\n", (numSplits - numPrunedSplits) * 2 + 1 );
	numPortals = 0;
	MakeOutsidePortals();
	MakeTreePortals_r( root );
	common->Printf( "\r%6d nodes portalized\n", numPortals );
}

/*
=============
LeakFile

Finds the shortest possible chain of portals that
leads from the outside leaf to a specific occupied leaf.
=============
*/
void idBrushBSP::LeakFile( const idStr &fileName ) {
	int count, next, s;
	idVec3 mid;
	idFile *lineFile;
	idBrushBSPNode *node, *nextNode;
	idBrushBSPPortal *p, *nextPortal;
	idStr qpath, name;

	if ( !outside->occupied ) {
		return;
	}

	qpath = fileName;
	qpath.SetFileExtension( "lin" );

	common->Printf( "writing %s...\n", qpath.c_str() );

	lineFile = fileSystem->OpenFileWrite( qpath, "fs_devpath" );
	if ( !lineFile ) {
		common->Error( "Couldn't open %s\n", qpath.c_str() );
		return;
	}

	count = 0;
	node = outside;
	while( node->occupied > 1 ) {

		// find the best portal exit
		next = node->occupied;
		for (p = node->portals; p; p = p->next[!s] ) {
			s = (p->nodes[0] == node);
			if ( p->nodes[s]->occupied && p->nodes[s]->occupied < next ) {
				nextPortal = p;
				nextNode = p->nodes[s];
				next = nextNode->occupied;
			}
		}
		node = nextNode;
		mid = nextPortal->winding->GetCenter();
		lineFile->Printf( "%f %f %f\n", mid[0], mid[1], mid[2] );
		count++;
	}

	// add the origin of the entity from which the leak was found
	lineFile->Printf( "%f %f %f\n", leakOrigin[0], leakOrigin[1], leakOrigin[2] );

	fileSystem->CloseFile( lineFile );
}

/*
============
idBrushBSP::FloodThroughPortals_r
============
*/
void idBrushBSP::FloodThroughPortals_r( idBrushBSPNode *node, int contents, int depth ) {
	idBrushBSPPortal *p;
	int s;

	if ( node->occupied ) {
		common->Error( "FloodThroughPortals_r: node already occupied\n" );
	}
	if ( !node ) {
		common->Error( "FloodThroughPortals_r: NULL node\n" );
	}

	node->occupied = depth;

	for ( p = node->portals; p; p = p->next[s] ) {
		s = (p->nodes[1] == node);

		// if the node at the other side of the portal is removed
		if ( !p->nodes[!s] ) {
			continue;
		}

		// if the node at the other side of the portal is occupied already
		if ( p->nodes[!s]->occupied ) {
			continue;
		}

		// can't flood through the portal if it has the seperating contents at the other side
		if ( p->nodes[!s]->contents & contents ) {
			continue;
		}

		// flood recursively through the current portal
		FloodThroughPortals_r( p->nodes[!s], contents, depth+1 );
	}
}

/*
============
idBrushBSP::FloodFromOrigin
============
*/
bool idBrushBSP::FloodFromOrigin( const idVec3 &origin, int contents ) {
	idBrushBSPNode *node;

	//find the leaf to start in
	node = root;
	while( node->children[0] && node->children[1] ) {

		if ( node->plane.Side( origin ) == PLANESIDE_BACK ) {
			node = node->children[1];
		}
		else {
			node = node->children[0];
		}
	}

	if ( !node ) {
		return false;
	}

	// if inside the inside/outside seperating contents
	if ( node->contents & contents ) {
		return false;
	}

	// if the node is already occupied
	if ( node->occupied ) {
		return false;
	}

	FloodThroughPortals_r( node, contents, 1 );

	return true;
}

/*
============
idBrushBSP::FloodFromEntities

  Marks all nodes that can be reached by entites.
============
*/
bool idBrushBSP::FloodFromEntities( const idMapFile *mapFile, int contents, const idStrList &classNames ) {
	int i, j;
	bool inside;
	idVec3 origin;
	idMapEntity *mapEnt;
	idStr classname;

	inside = false;
	outside->occupied = 0;

	// skip the first entity which is assumed to be the worldspawn
	for ( i = 1; i < mapFile->GetNumEntities(); i++ ) {

		mapEnt = mapFile->GetEntity( i );

		if ( !mapEnt->epairs.GetVector( "origin", "", origin ) ) {
			continue;
		}

		if ( !mapEnt->epairs.GetString( "classname", "", classname ) ) {
			continue;
		}

		for ( j = 0; j < classNames.Num(); j++ ) {
			if ( classname.Icmp( classNames[j] ) == 0 ) {
				break;
			}
		}

		if ( j >= classNames.Num() ) {
			continue;
		}

		origin[2] += 1;

		// nudge around a little
		if ( FloodFromOrigin( origin, contents ) ) {
			inside = true;
		}

		if ( outside->occupied ) {
			leakOrigin = origin;
			break;
		}
	}

	if ( !inside ) {
		common->Warning( "no entities inside" );
	}
	else if ( outside->occupied ) {
		common->Warning( "reached outside from entity %d (%s)", i, classname.c_str() );
	}

	return ( inside && !outside->occupied );
}

/*
============
idBrushBSP::RemoveOutside_r
============
*/
void idBrushBSP::RemoveOutside_r( idBrushBSPNode *node, int contents ) {

	if ( !node ) {
		return;
	}

	if ( node->children[0] || node->children[1] ) {
		RemoveOutside_r( node->children[0], contents );
		RemoveOutside_r( node->children[1], contents );
		return;
	}

	if ( !node->occupied ) {
		if ( !( node->contents & contents ) ) {
			outsideLeafNodes++;
			node->contents |= contents;
		}
		else {
			solidLeafNodes++;
		}
	}
	else {
		insideLeafNodes++;
	}
}

/*
============
idBrushBSP::RemoveOutside
============
*/
bool idBrushBSP::RemoveOutside( const idMapFile *mapFile, int contents, const idStrList &classNames ) {
	common->Printf( "[Remove Outside]\n" );

	solidLeafNodes = outsideLeafNodes = insideLeafNodes = 0;

	if ( !FloodFromEntities( mapFile, contents, classNames ) ) {
		return false;
	}

	RemoveOutside_r( root, contents );

	common->Printf( "%6d solid leaf nodes\n", solidLeafNodes );
	common->Printf( "%6d outside leaf nodes\n", outsideLeafNodes );
	common->Printf( "%6d inside leaf nodes\n", insideLeafNodes );

	//PruneTree( contents );

	return true;
}

/*
============
idBrushBSP::SetPortalPlanes_r
============
*/
void idBrushBSP::SetPortalPlanes_r( idBrushBSPNode *node, idPlaneSet &planeList ) {
	int s;
	idBrushBSPPortal *p;

	if ( !node ) {
		return;
	}

	for ( p = node->portals; p; p = p->next[s] ) {
		s = (p->nodes[1] == node);
		if ( p->planeNum == -1 ) {
			p->planeNum = planeList.FindPlane( p->plane, PORTAL_PLANE_NORMAL_EPSILON, PORTAL_PLANE_DIST_EPSILON );
		}
	}
	SetPortalPlanes_r( node->children[0], planeList );
	SetPortalPlanes_r( node->children[1], planeList );
}

/*
============
idBrushBSP::SetPortalPlanes

  give all portals a plane number
============
*/
void idBrushBSP::SetPortalPlanes( void ) {
	SetPortalPlanes_r( root, portalPlanes );
}

/*
============
idBrushBSP::MergeLeafNodePortals
============
*/
void idBrushBSP::MergeLeafNodePortals( idBrushBSPNode *node, int skipContents ) {
	int s1, s2;
	bool foundPortal;
	idBrushBSPPortal *p1, *p2, *nextp1, *nextp2;
	idWinding *newWinding, *reverse;

	// pass 1: merge all portals that seperate the same leaf nodes
	for ( p1 = node->GetPortals(); p1; p1 = nextp1 ) {
		s1 = (p1->GetNode(1) == node);
		nextp1 = p1->Next(s1);

		for ( p2 = nextp1; p2; p2 = nextp2 ) {
			s2 = (p2->GetNode(1) == node);
			nextp2 = p2->Next(s2);

			// if both portals seperate the same leaf nodes
			if ( p1->nodes[!s1] == p2->nodes[!s2] ) { 

				// add the winding of p2 to the winding of p1
				p1->winding->AddToConvexHull( p2->winding, p1->plane.Normal() );

				// delete p2
				p2->RemoveFromNode( p2->nodes[0] );
				p2->RemoveFromNode( p2->nodes[1] );
				delete p2;

				numMergedPortals++;

				nextp1 = node->GetPortals();
				break;
			}
		}
	}

	// pass 2: merge all portals in the same plane if they all have the skip contents at the other side
	for ( p1 = node->GetPortals(); p1; p1 = nextp1 ) {
		s1 = (p1->GetNode(1) == node);
		nextp1 = p1->Next(s1);

		if ( !(p1->nodes[!s1]->contents & skipContents) ) {
			continue;
		}

		// test if all portals in this plane have the skip contents at the other side
		foundPortal = false;
		for ( p2 = node->GetPortals(); p2; p2 = nextp2 ) {
			s2 = (p2->GetNode(1) == node);
			nextp2 = p2->Next(s2);

			if ( p2 == p1 || (p2->planeNum & ~1) != (p1->planeNum & ~1) ) {
				continue;
			}
			foundPortal = true;
			if ( !(p2->nodes[!s2]->contents & skipContents) ) {
				break;
			}
		}

		// if all portals in this plane have the skip contents at the other side
		if ( !p2 && foundPortal ) {
			for ( p2 = node->GetPortals(); p2; p2 = nextp2 ) {
				s2 = (p2->GetNode(1) == node);
				nextp2 = p2->Next(s2);

				if ( p2 == p1 || (p2->planeNum & ~1) != (p1->planeNum & ~1) ) {
					continue;
				}

				// add the winding of p2 to the winding of p1
				p1->winding->AddToConvexHull( p2->winding, p1->plane.Normal() );

				// delete p2
				p2->RemoveFromNode( p2->nodes[0] );
				p2->RemoveFromNode( p2->nodes[1] );
				delete p2;

				numMergedPortals++;
			}
			nextp1 = node->GetPortals();
		}
	}

	// pass 3: try to merge portals in the same plane that have the skip contents at the other side
	for ( p1 = node->GetPortals(); p1; p1 = nextp1 ) {
		s1 = (p1->GetNode(1) == node);
		nextp1 = p1->Next(s1);

		if ( !(p1->nodes[!s1]->contents & skipContents) ) {
			continue;
		}

		for ( p2 = nextp1; p2; p2 = nextp2 ) {
			s2 = (p2->GetNode(1) == node);
			nextp2 = p2->Next(s2);

			if ( !(p2->nodes[!s2]->contents & skipContents) ) {
				continue;
			}

			if ( (p2->planeNum & ~1) != (p1->planeNum & ~1) ) {
				continue;
			}

			// try to merge the two portal windings
			if ( p2->planeNum == p1->planeNum ) {
				newWinding = p1->winding->TryMerge( *p2->winding, p1->plane.Normal() );
			}
			else {
				reverse = p2->winding->Reverse();
				newWinding = p1->winding->TryMerge( *reverse, p1->plane.Normal() );
				delete reverse;
			}

			// if successfully merged
			if ( newWinding ) {

				// replace the winding of the first portal
				delete p1->winding;
				p1->winding = newWinding;

				// delete p2
				p2->RemoveFromNode( p2->nodes[0] );
				p2->RemoveFromNode( p2->nodes[1] );
				delete p2;

				numMergedPortals++;

				nextp1 = node->GetPortals();
				break;
			}
		}
	}
}

/*
============
idBrushBSP::MergePortals_r
============
*/
void idBrushBSP::MergePortals_r( idBrushBSPNode *node, int skipContents ) {

	if ( !node ) {
		return;
	}

	if ( node->contents & skipContents ) {
		return;
	}

	if ( !node->children[0] && !node->children[1] ) {
		MergeLeafNodePortals( node, skipContents );
		return;
	}

	MergePortals_r( node->children[0], skipContents );
	MergePortals_r( node->children[1], skipContents );
}

/*
============
idBrushBSP::MergePortals
============
*/
void idBrushBSP::MergePortals( int skipContents ) {
	numMergedPortals = 0;
	common->Printf( "[Merge Portals]\n" );
	SetPortalPlanes();
	MergePortals_r( root, skipContents );
	common->Printf( "%6d portals merged\n", numMergedPortals );
}

/*
============
idBrushBSP::PruneMergedTree_r
============
*/
void idBrushBSP::PruneMergedTree_r( idBrushBSPNode *node ) {
	int i;
	idBrushBSPNode *leafNode;

	if ( !node ) {
		return;
	}

	PruneMergedTree_r( node->children[0] );
	PruneMergedTree_r( node->children[1] );

	for ( i = 0; i < 2; i++ ) {
		if ( node->children[i] ) {
			leafNode = node->children[i]->children[0];
			if ( leafNode && leafNode == node->children[i]->children[1] ) {
				if ( leafNode->parent == node->children[i] ) {
					leafNode->parent = node;
				}
				delete node->children[i];
				node->children[i] = leafNode;
			}
		}
	}
}

/*
============
idBrushBSP::UpdateTreeAfterMerge_r
============
*/
void idBrushBSP::UpdateTreeAfterMerge_r( idBrushBSPNode *node, const idBounds &bounds, idBrushBSPNode *oldNode, idBrushBSPNode *newNode ) {

	if ( !node ) {
		return;
	}

	if ( !node->children[0] && !node->children[1] ) {
		return;
	}

	if ( node->children[0] == oldNode ) {
		node->children[0] = newNode;
	}
	if ( node->children[1] == oldNode ) {
		node->children[1] = newNode;
	}

	switch( bounds.PlaneSide( node->plane, 2.0f ) ) {
		case PLANESIDE_FRONT:
			UpdateTreeAfterMerge_r( node->children[0], bounds, oldNode, newNode );
			break;
		case PLANESIDE_BACK:
			UpdateTreeAfterMerge_r( node->children[1], bounds, oldNode, newNode );
			break;
		default:
			UpdateTreeAfterMerge_r( node->children[0], bounds, oldNode, newNode );
			UpdateTreeAfterMerge_r( node->children[1], bounds, oldNode, newNode );
			break;
	}
}

/*
============
idBrushBSP::TryMergeLeafNodes

  NOTE: multiple brances of the BSP tree might point to the same leaf node after merging
============
*/
bool idBrushBSP::TryMergeLeafNodes( idBrushBSPPortal *portal, int side ) {
	int i, j, k, s1, s2, s;
	idBrushBSPNode *nodes[2], *node1, *node2;
	idBrushBSPPortal *p1, *p2, *p, *nextp;
	idPlane plane;
	idWinding *w;
	idBounds bounds, b;

	nodes[0] = node1 = portal->nodes[side];
	nodes[1] = node2 = portal->nodes[!side];

	// check if the merged node would still be convex
	for ( i = 0; i < 2; i++ ) {

		j = !i;

		for ( p1 = nodes[i]->portals; p1; p1 = p1->next[s1] ) {
			s1 = (p1->nodes[1] == nodes[i]);

			if ( p1->nodes[!s1] == nodes[j] ) {
				continue;
			}

			if ( s1 ) {
				plane = -p1->plane;
			}
			else {
				plane = p1->plane;
			}

			// all the non seperating portals of the other node should be at the front or on the plane
			for ( p2 = nodes[j]->portals; p2; p2 = p2->next[s2] ) {
				s2 = (p2->nodes[1] == nodes[j]);

				if ( p2->nodes[!s2] == nodes[i] ) {
					continue;
				}

				w = p2->winding;
				for ( k = 0; k < w->GetNumPoints(); k++ ) {
					if ( plane.Distance( (*w)[k].ToVec3() ) < -0.1f ) {
						return false;
					}
				}
			}
		}
	}

	// remove all portals that seperate the two nodes
	for ( p = node1->portals; p; p = nextp ) {
		s = (p->nodes[1] == node1);
		nextp = p->next[s];
		
		if ( p->nodes[!s] == node2 ) {
			p->RemoveFromNode( p->nodes[0] );
			p->RemoveFromNode( p->nodes[1] );
			delete p;
		}
	}

	// move all portals of node2 to node1
	for ( p = node2->portals; p; p = node2->portals ) {
		s = (p->nodes[1] == node2);

		nodes[s] = node1;
		nodes[!s] = p->nodes[!s];
		p->RemoveFromNode( p->nodes[0] );
		p->RemoveFromNode( p->nodes[1] );
		p->AddToNodes( nodes[0], nodes[1] );
	}

	// get bounds for the new node
	bounds.Clear();
	for ( p = node1->portals; p; p = p->next[s] ) {
		s = (p->nodes[1] == node1);
		p->GetWinding()->GetBounds( b );
		bounds += b;
	}

	// replace every reference to node2 by a reference to node1
	UpdateTreeAfterMerge_r( root, bounds, node2, node1 );

	delete node2;

	return true;
}

/*
============
idBrushBSP::MeltFloor_r

  flood through portals touching the bounds to find all vertices that might be inside the bounds
============
*/
void idBrushBSP::MeltFlood_r( idBrushBSPNode *node, int skipContents, idBounds &bounds, idVectorSet<idVec3,3> &vertexList ) {
	int s1, i;
	idBrushBSPPortal *p1;
	idBounds b;
	const idWinding *w;

	node->SetFlag( NODE_VISITED );

	for ( p1 = node->GetPortals(); p1; p1 = p1->Next(s1) ) {
		s1 = (p1->GetNode(1) == node);
	
		if ( p1->GetNode( !s1 )->GetFlags() & NODE_VISITED ) {
			continue;
		}

		w = p1->GetWinding();

		for ( i = 0; i < w->GetNumPoints(); i++ ) {
			if ( bounds.ContainsPoint( (*w)[i].ToVec3() ) ) {
				vertexList.FindVector( (*w)[i].ToVec3(), VERTEX_MELT_EPSILON );
			}
		}
	}

	for ( p1 = node->GetPortals(); p1; p1 = p1->Next(s1) ) {
		s1 = (p1->GetNode(1) == node);

		if ( p1->GetNode( !s1 )->GetFlags() & NODE_VISITED ) {
			continue;
		}

		if ( p1->GetNode( !s1 )->GetContents() & skipContents ) {
			continue;
		}

		w = p1->GetWinding();
		w->GetBounds( b );

		if ( !bounds.IntersectsBounds( b ) ) {
			continue;
		}

		MeltFlood_r( p1->GetNode( !s1 ), skipContents, bounds, vertexList );
	}
}

/*
============
idBrushBSP::MeltLeafNodePortals
============
*/
void idBrushBSP::MeltLeafNodePortals( idBrushBSPNode *node, int skipContents, idVectorSet<idVec3,3> &vertexList ) {
	int s1, i;
	idBrushBSPPortal *p1;
	idBounds bounds;

	if ( node->GetFlags() & NODE_DONE ) {
		return;
	}

	node->SetFlag( NODE_DONE );

	// melt things together
	for ( p1 = node->GetPortals(); p1; p1 = p1->Next(s1) ) {
		s1 = (p1->GetNode(1) == node);

		if ( p1->GetNode( !s1 )->GetFlags() & NODE_DONE ) {
			continue;
		}

		p1->winding->GetBounds( bounds );
		bounds.ExpandSelf( 2 * VERTEX_MELT_HASH_SIZE * VERTEX_MELT_EPSILON );
		vertexList.Init( bounds[0], bounds[1], VERTEX_MELT_HASH_SIZE, 128 );

		// get all vertices to be considered
		MeltFlood_r( node, skipContents, bounds, vertexList );
		node->RemoveFlagFlood( NODE_VISITED );

		for ( i = 0; i < vertexList.Num(); i++ ) {
			if ( p1->winding->InsertPointIfOnEdge( vertexList[i], p1->plane, 0.1f ) ) {
				numInsertedPoints++;
			}
		}
	}
	DisplayRealTimeString( "\r%6d", numInsertedPoints );
}

/*
============
idBrushBSP::MeltPortals_r
============
*/
void idBrushBSP::MeltPortals_r( idBrushBSPNode *node, int skipContents, idVectorSet<idVec3,3> &vertexList ) {
	if ( !node ) {
		return;
	}

	if ( node->contents & skipContents ) {
		return;
	}

	if ( !node->children[0] && !node->children[1] ) {
		MeltLeafNodePortals( node, skipContents, vertexList );
		return;
	}

	MeltPortals_r( node->children[0], skipContents, vertexList );
	MeltPortals_r( node->children[1], skipContents, vertexList );
}

/*
============
idBrushBSP::RemoveLeafNodeColinearPoints
============
*/
void idBrushBSP::RemoveLeafNodeColinearPoints( idBrushBSPNode *node ) {
	int s1;
	idBrushBSPPortal *p1;

	// remove colinear points
	for ( p1 = node->GetPortals(); p1; p1 = p1->Next(s1) ) {
		s1 = (p1->GetNode(1) == node);
		p1->winding->RemoveColinearPoints( p1->plane.Normal(), 0.1f );
	}
}

/*
============
idBrushBSP::RemoveColinearPoints_r
============
*/
void idBrushBSP::RemoveColinearPoints_r( idBrushBSPNode *node, int skipContents ) {
	if ( !node ) {
		return;
	}

	if ( node->contents & skipContents ) {
		return;
	}

	if ( !node->children[0] && !node->children[1] ) {
		RemoveLeafNodeColinearPoints( node );
		return;
	}

	RemoveColinearPoints_r( node->children[0], skipContents );
	RemoveColinearPoints_r( node->children[1], skipContents );
}

/*
============
idBrushBSP::MeltPortals
============
*/
void idBrushBSP::MeltPortals( int skipContents ) {
	idVectorSet<idVec3,3> vertexList;

	numInsertedPoints = 0;
	common->Printf( "[Melt Portals]\n" );
	RemoveColinearPoints_r( root, skipContents );
	MeltPortals_r( root, skipContents, vertexList );
	root->RemoveFlagRecurse( NODE_DONE );
	common->Printf( "\r%6d points inserted\n", numInsertedPoints );
}
